home *** CD-ROM | disk | FTP | other *** search
/ C/C++ Users Group Library 1996 July / C-C++ Users Group Library July 1996.iso / vol_200 / 271_02 / async.doc < prev    next >
Text File  |  1987-08-18  |  4KB  |  113 lines
  1.  
  2.  
  3.         NAME
  4.                 readchar -- read a character from serial port
  5.                 ready_rcv -- check for character availability
  6.                 ready_xmt -- check if port can accept a char to send
  7.                 setport -- set port configuration
  8.                 writechar -- send a char to the serial port
  9.  
  10.         SYNOPSIS
  11.                 r = readchar(port);
  12.                 x = ready_rcv(port);
  13.                 x = ready_xmt(port);
  14.                 (void) setport(port, r);
  15.                 (void) writechar(port, r);
  16.                 unsigned char r;   character to send or receive
  17.                 int port;          port number
  18.                 int x;             TRUE if condition exists, else FALSE (0)
  19.  
  20.  
  21.         DESCRIPTION
  22.            These are very low level (direct port access) subroutines
  23.            to enable I/O through COM1 through COM4.  Only setport() uses
  24.            BIOS int 14H.  These functions are not intended to be the
  25.            ultimate in async functions, but a starting point for an
  26.            integrated set of async functions, and a means of getting at
  27.            the serial port directly for speed and to work around the
  28.            problems that some "clone" BIOS routines have in returning
  29.            proper status values.  File "smdefs.h" contains #defines
  30.            to handle these ports mnemonically.
  31.  
  32.            The value to use for the setport() function is an 8-bit
  33.            value, bitwise organized as follows:
  34.                  bits 1,0:     10 = 7-bit data, 11 = 8-bit data
  35.                  bit  2:        0 = 1 stop bit, 1 = 2 stop bits
  36.                  bits 4,3:     x0 = No Parity, 01 = odd, 11 = even
  37.                  bits 7,6,5:   baud rate:
  38.                                000 = 110 baud (use 2 stop bits)
  39.                                001 = 150 baud
  40.                                010 = 300 baud
  41.                                011 = 600 baud
  42.                                100 = 1200 baud
  43.                                101 = 2400 baud
  44.                                110 = 4800 baud
  45.                                111 = 9600 baud
  46.  
  47.            ready_rcv() returns a TRUE condition if a character is
  48.            waiting to be read, but no error conditions are returned.
  49.            ready_xmt() returns a TRUE condition if the transmit
  50.            holding register is empty; i.e., the transmitter can accept
  51.            a character to send.  In both these functions, the status
  52.            returned is a result of reading the port status and masking
  53.            all but the relevant bit.  These routines will NOT return
  54.            errors such as overrun or parity.
  55.  
  56.         async functions,      page 2
  57.  
  58.  
  59.  
  60.  
  61.            readchar() will return the character waiting in the receiver
  62.            register of the port.  It is returned as an unsigned char
  63.            to facilitate 8-bit binary transfer protocols.
  64.            writechar() will place the specified unsigned char into the
  65.            transmitter buffer register where it will be sent.
  66.  
  67.            If the program "loop" is short and fast enough, these functions
  68.            will be ample to allow communications at up to 9600 baud.
  69.            A program has already been implemented to communicate with a
  70.            prom programmer at this rate, so it can be done.  However,
  71.            when the program does not poll the receiver fast enough it
  72.            is likely that characters may be lost and the maximum usable
  73.            baud rate will be lower.  It is highly unlikely that baud rates
  74.            less than 2400 baud will be necessary if the program is properly
  75.            structured.
  76.  
  77.  
  78.  
  79.         EXAMPLE
  80.  
  81.            /* this routine receives characters from COM1 at one
  82.            ** speed and resends them to COM2 at another speed */
  83.  
  84.             unsigned char i;
  85.  
  86.             setport(SER1, 0xe3);  /* set COM1 to 9600 baud, No parity,
  87.                                   ** 8-bits, 1 stop bit */
  88.             setport(SER2, 0xc3);  /* set COM2 the same, except 4800 baud */
  89.  
  90.             while(TRUE) {
  91.                if(!ready_rcv(SER1)) continue;  /* wait for a char */
  92.                i = readchar(SER1);     /* fetch it */
  93.                while(!ready_xmt(SER2));/* wait for transmitter to be ready */
  94.                writechar(SER2, i);  /* then send it */
  95.                }
  96.  
  97.  
  98.  
  99.  
  100.  
  101.  
  102.  
  103.  
  104.  
  105.  
  106.  
  107.  
  108.  
  109.  
  110.  
  111.  
  112.         This function is found in SMTCx.LIB for the Turbo-C Compiler.
  113.